{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3D classification example based on DenseNet\n",
    "\n",
    "This tutorial shows an example of 3D classification task based on DenseNet and array format transforms.\n",
    "\n",
    "Here, the task is given to classify MR images into male/female.\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Project-MONAI/tutorials/blob/master/3d_classification/torch/densenet_training_array.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python -c \"import monai\" || pip install -q \"monai-weekly[nibabel, tqdm]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MONAI version: 0.4.0+35.g6adbcde\n",
      "Numpy version: 1.19.5\n",
      "Pytorch version: 1.7.1\n",
      "MONAI flags: HAS_EXT = False, USE_COMPILED = False\n",
      "MONAI rev id: 6adbcdee45c16f18f5b713575af3410437177311\n",
      "\n",
      "Optional dependencies:\n",
      "Pytorch Ignite version: 0.4.2\n",
      "Nibabel version: 3.2.1\n",
      "scikit-image version: 0.18.1\n",
      "Pillow version: 7.0.0\n",
      "Tensorboard version: 2.4.0\n",
      "gdown version: 3.12.2\n",
      "TorchVision version: 0.8.2\n",
      "ITK version: 5.1.2\n",
      "tqdm version: 4.51.0\n",
      "lmdb version: 1.0.0\n",
      "psutil version: 5.8.0\n",
      "\n",
      "For details about installing the optional dependencies, please visit:\n",
      "    https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Copyright 2020 MONAI Consortium\n",
    "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#     http://www.apache.org/licenses/LICENSE-2.0\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License.\n",
    "\n",
    "import logging\n",
    "import os\n",
    "import sys\n",
    "import tempfile\n",
    "import shutil\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "import numpy as np\n",
    "\n",
    "import monai\n",
    "from monai.apps import download_and_extract\n",
    "from monai.config import print_config\n",
    "from monai.data import CacheDataset, DataLoader, ImageDataset\n",
    "from monai.transforms import (\n",
    "    AddChannel,\n",
    "    Compose,\n",
    "    RandRotate90,\n",
    "    Resize,\n",
    "    ScaleIntensity,\n",
    "    EnsureType,\n",
    "    Randomizable,\n",
    "    LoadImaged,\n",
    "    EnsureTyped,\n",
    ")\n",
    "\n",
    "logging.basicConfig(stream=sys.stdout, level=logging.INFO)\n",
    "print_config()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/workspace/data/medical\n"
     ]
    }
   ],
   "source": [
    "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n",
    "root_dir = tempfile.mkdtemp() if directory is None else directory\n",
    "print(root_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class IXIDataset(Randomizable, CacheDataset):\n",
    "    resource = \"http://biomedic.doc.ic.ac.uk/\" \\\n",
    "        + \"brain-development/downloads/IXI/IXI-T1.tar\"\n",
    "    md5 = \"34901a0593b41dd19c1a1f746eac2d58\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        root_dir,\n",
    "        section,\n",
    "        transform,\n",
    "        download=False,\n",
    "        seed=0,\n",
    "        val_frac=0.2,\n",
    "        test_frac=0.2,\n",
    "        cache_num=sys.maxsize,\n",
    "        cache_rate=1.0,\n",
    "        num_workers=0,\n",
    "    ):\n",
    "        if not os.path.isdir(root_dir):\n",
    "            raise ValueError(\"Root directory root_dir must be a directory.\")\n",
    "        self.section = section\n",
    "        self.val_frac = val_frac\n",
    "        self.test_frac = test_frac\n",
    "        self.set_random_state(seed=seed)\n",
    "        dataset_dir = os.path.join(root_dir, \"ixi\")\n",
    "        tarfile_name = f\"{dataset_dir}.tar\"\n",
    "        if download:\n",
    "            download_and_extract(\n",
    "                self.resource, tarfile_name, dataset_dir, self.md5)\n",
    "        # as a quick demo, we just use 10 images to show\n",
    "\n",
    "        self.datalist = [\n",
    "            {\"image\": os.path.join(\n",
    "                dataset_dir, \"IXI314-IOP-0889-T1.nii.gz\"), \"label\": 0},\n",
    "            {\"image\": os.path.join(\n",
    "                dataset_dir, \"IXI249-Guys-1072-T1.nii.gz\"), \"label\": 0},\n",
    "            {\"image\": os.path.join(\n",
    "                dataset_dir, \"IXI609-HH-2600-T1.nii.gz\"), \"label\": 0},\n",
    "            {\"image\": os.path.join(\n",
    "                dataset_dir, \"IXI173-HH-1590-T1.nii.gz\"), \"label\": 1},\n",
    "            {\"image\": os.path.join(\n",
    "                dataset_dir, \"IXI020-Guys-0700-T1.nii.gz\"), \"label\": 0},\n",
    "            {\"image\": os.path.join(\n",
    "                dataset_dir, \"IXI342-Guys-0909-T1.nii.gz\"), \"label\": 0},\n",
    "            {\"image\": os.path.join(\n",
    "                dataset_dir, \"IXI134-Guys-0780-T1.nii.gz\"), \"label\": 0},\n",
    "            {\"image\": os.path.join(\n",
    "                dataset_dir, \"IXI577-HH-2661-T1.nii.gz\"), \"label\": 1},\n",
    "            {\"image\": os.path.join(\n",
    "                dataset_dir, \"IXI066-Guys-0731-T1.nii.gz\"), \"label\": 1},\n",
    "            {\"image\": os.path.join(\n",
    "                dataset_dir, \"IXI130-HH-1528-T1.nii.gz\"), \"label\": 0},\n",
    "        ]\n",
    "        data = self._generate_data_list()\n",
    "        super().__init__(\n",
    "            data, transform, cache_num=cache_num,\n",
    "            cache_rate=cache_rate, num_workers=num_workers,\n",
    "        )\n",
    "\n",
    "    def randomize(self, data=None):\n",
    "        self.rann = self.R.random()\n",
    "\n",
    "    def _generate_data_list(self):\n",
    "        data = []\n",
    "        for d in self.datalist:\n",
    "            self.randomize()\n",
    "            if self.section == \"training\":\n",
    "                if self.rann < self.val_frac + self.test_frac:\n",
    "                    continue\n",
    "            elif self.section == \"validation\":\n",
    "                if self.rann >= self.val_frac:\n",
    "                    continue\n",
    "            elif self.section == \"test\":\n",
    "                if self.rann < self.val_frac or \\\n",
    "                        self.rann >= self.val_frac + self.test_frac:\n",
    "                    continue\n",
    "            else:\n",
    "                raise ValueError(\n",
    "                    f\"Unsupported section: {self.section}, \"\n",
    "                    \"available options are ['training', 'validation', 'test'].\"\n",
    "                )\n",
    "            data.append(d)\n",
    "        return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Verified 'ixi.tar', md5: 34901a0593b41dd19c1a1f746eac2d58.\n",
      "file /workspace/data/medical/ixi.tar exists, skip downloading.\n",
      "Verified 'ixi.tar', md5: 34901a0593b41dd19c1a1f746eac2d58.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 9/9 [00:02<00:00,  3.63it/s]\n"
     ]
    }
   ],
   "source": [
    "train_ds = IXIDataset(\n",
    "    root_dir=root_dir,\n",
    "    section=\"training\",\n",
    "    transform=Compose([LoadImaged(\"image\"), EnsureTyped(\"image\")]),\n",
    "    download=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'torch.Tensor'> torch.Size([2, 1, 96, 96, 96]) tensor([0, 0])\n",
      "----------\n",
      "epoch 1/5\n",
      "1/5, train_loss: 0.6933\n",
      "2/5, train_loss: 0.7689\n",
      "3/5, train_loss: 0.7098\n",
      "4/5, train_loss: 0.6135\n",
      "5/5, train_loss: 0.7706\n",
      "epoch 1 average loss: 0.7112\n",
      "----------\n",
      "epoch 2/5\n",
      "1/5, train_loss: 0.7779\n",
      "2/5, train_loss: 0.7371\n",
      "3/5, train_loss: 0.7766\n",
      "4/5, train_loss: 0.5238\n",
      "5/5, train_loss: 0.6517\n",
      "epoch 2 average loss: 0.6934\n",
      "saved new best metric model\n",
      "current epoch: 2 current accuracy: 0.6000 best accuracy: 0.6000 at epoch 2\n",
      "----------\n",
      "epoch 3/5\n",
      "1/5, train_loss: 0.7595\n",
      "2/5, train_loss: 0.6735\n",
      "3/5, train_loss: 0.4000\n",
      "4/5, train_loss: 0.6529\n",
      "5/5, train_loss: 0.7401\n",
      "epoch 3 average loss: 0.6452\n",
      "----------\n",
      "epoch 4/5\n",
      "1/5, train_loss: 0.8956\n",
      "2/5, train_loss: 0.6899\n",
      "3/5, train_loss: 0.7104\n",
      "4/5, train_loss: 0.7479\n",
      "5/5, train_loss: 0.7186\n",
      "epoch 4 average loss: 0.7525\n",
      "current epoch: 4 current accuracy: 0.6000 best accuracy: 0.6000 at epoch 2\n",
      "----------\n",
      "epoch 5/5\n",
      "1/5, train_loss: 0.7230\n",
      "2/5, train_loss: 0.6702\n",
      "3/5, train_loss: 0.8378\n",
      "4/5, train_loss: 0.6772\n",
      "5/5, train_loss: 0.7005\n",
      "epoch 5 average loss: 0.7218\n",
      "train completed, best_metric: 0.6000 at epoch: 2\n"
     ]
    }
   ],
   "source": [
    "# IXI dataset as a demo, downloadable from https://brain-development.org/ixi-dataset/\n",
    "images = [\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI314-IOP-0889-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI249-Guys-1072-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI609-HH-2600-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI173-HH-1590-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI020-Guys-0700-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI342-Guys-0909-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI134-Guys-0780-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI577-HH-2661-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI066-Guys-0731-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI130-HH-1528-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI607-Guys-1097-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI175-HH-1570-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI385-HH-2078-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI344-Guys-0905-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI409-Guys-0960-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI584-Guys-1129-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI253-HH-1694-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI092-HH-1436-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI574-IOP-1156-T1.nii.gz\"]),\n",
    "    os.sep.join([root_dir, \"ixi\", \"IXI585-Guys-1130-T1.nii.gz\"]),\n",
    "]\n",
    "\n",
    "# 2 binary labels for gender classification: man and woman\n",
    "labels = np.array([0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1,\n",
    "                   0, 1, 0, 1, 0, 1, 0], dtype=np.int64)\n",
    "\n",
    "# Define transforms\n",
    "train_transforms = Compose([ScaleIntensity(), AddChannel(), Resize(\n",
    "    (96, 96, 96)), RandRotate90(), EnsureType()])\n",
    "val_transforms = Compose(\n",
    "    [ScaleIntensity(), AddChannel(), Resize((96, 96, 96)), EnsureType()])\n",
    "\n",
    "# Define nifti dataset, data loader\n",
    "check_ds = ImageDataset(image_files=images, labels=labels,\n",
    "                        transform=train_transforms)\n",
    "check_loader = DataLoader(check_ds, batch_size=2,\n",
    "                          num_workers=2, pin_memory=torch.cuda.is_available())\n",
    "im, label = monai.utils.misc.first(check_loader)\n",
    "print(type(im), im.shape, label)\n",
    "\n",
    "# create a training data loader\n",
    "train_ds = ImageDataset(\n",
    "    image_files=images[:10], labels=labels[:10], transform=train_transforms)\n",
    "train_loader = DataLoader(train_ds, batch_size=2, shuffle=True,\n",
    "                          num_workers=2, pin_memory=torch.cuda.is_available())\n",
    "\n",
    "# create a validation data loader\n",
    "val_ds = ImageDataset(\n",
    "    image_files=images[-10:], labels=labels[-10:], transform=val_transforms)\n",
    "val_loader = DataLoader(val_ds, batch_size=2, num_workers=2,\n",
    "                        pin_memory=torch.cuda.is_available())\n",
    "\n",
    "# Create DenseNet121, CrossEntropyLoss and Adam optimizer\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model = monai.networks.nets.DenseNet121(\n",
    "    spatial_dims=3, in_channels=1, out_channels=2).to(device)\n",
    "loss_function = torch.nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), 1e-5)\n",
    "\n",
    "# start a typical PyTorch training\n",
    "val_interval = 2\n",
    "best_metric = -1\n",
    "best_metric_epoch = -1\n",
    "epoch_loss_values = []\n",
    "metric_values = []\n",
    "writer = SummaryWriter()\n",
    "max_epochs = 5\n",
    "for epoch in range(max_epochs):\n",
    "    print(\"-\" * 10)\n",
    "    print(f\"epoch {epoch + 1}/{max_epochs}\")\n",
    "    model.train()\n",
    "    epoch_loss = 0\n",
    "    step = 0\n",
    "    for batch_data in train_loader:\n",
    "        step += 1\n",
    "        inputs, labels = batch_data[0].to(device), batch_data[1].to(device)\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(inputs)\n",
    "        loss = loss_function(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        epoch_loss += loss.item()\n",
    "        epoch_len = len(train_ds) // train_loader.batch_size\n",
    "        print(f\"{step}/{epoch_len}, train_loss: {loss.item():.4f}\")\n",
    "        writer.add_scalar(\"train_loss\", loss.item(), epoch_len * epoch + step)\n",
    "    epoch_loss /= step\n",
    "    epoch_loss_values.append(epoch_loss)\n",
    "    print(f\"epoch {epoch + 1} average loss: {epoch_loss:.4f}\")\n",
    "\n",
    "    if (epoch + 1) % val_interval == 0:\n",
    "        model.eval()\n",
    "        with torch.no_grad():\n",
    "            num_correct = 0.0\n",
    "            metric_count = 0\n",
    "            for val_data in val_loader:\n",
    "                val_images, val_labels = val_data[0].to(\n",
    "                    device), val_data[1].to(device)\n",
    "                val_outputs = model(val_images)\n",
    "                value = torch.eq(val_outputs.argmax(dim=1), val_labels)\n",
    "                metric_count += len(value)\n",
    "                num_correct += value.sum().item()\n",
    "            metric = num_correct / metric_count\n",
    "            metric_values.append(metric)\n",
    "            if metric > best_metric:\n",
    "                best_metric = metric\n",
    "                best_metric_epoch = epoch + 1\n",
    "                torch.save(model.state_dict(),\n",
    "                           \"best_metric_model_classification3d_array.pth\")\n",
    "                print(\"saved new best metric model\")\n",
    "            print(\n",
    "                \"current epoch: {} current accuracy: {:.4f} \"\n",
    "                \"best accuracy: {:.4f} at epoch {}\".format(\n",
    "                    epoch + 1, metric, best_metric, best_metric_epoch\n",
    "                )\n",
    "            )\n",
    "            writer.add_scalar(\"val_accuracy\", metric, epoch + 1)\n",
    "print(\n",
    "    f\"train completed, best_metric: {best_metric:.4f} \"\n",
    "    f\"at epoch: {best_metric_epoch}\")\n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Occlusion sensitivity\n",
    "One method for trying to visualise why the network made a given prediction is occlusion sensitivity. We occlude part of the image, and see how the probability of a given prediction changes. We then iterate over the image, moving the occluded portion as we go, and in doing so we build up a sensitivity map detailing which areas were the most important in making the decision.\n",
    "\n",
    "#### Bounds\n",
    "If we were to test the occlusion centred on all voxels in our image, we would have to do `torch.prod(im.shape) = 96^3 = ~1e6` predictions. We can use the bounding box to only to the estimations in a region of interest, for example over one slice.\n",
    "\n",
    "To do this, we simply give the bounding box as `(minC,maxC,minD,maxD,minH,maxH,minW,maxW)`. We can use `-1` for any value to use its full extent (`0` and `im.shape-1` for min's and max's, respectively).\n",
    "\n",
    "#### Output\n",
    "The output image in this example will look fairly bad, since our network hasn't been trained for very long. Training for longer should improve the quality of the occlusion map."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a validation data loader\n",
    "test_ds = ImageDataset(\n",
    "    image_files=images[-10:], labels=labels[-10:], transform=val_transforms)\n",
    "test_loader = DataLoader(val_ds, batch_size=1, num_workers=2,\n",
    "                         pin_memory=torch.cuda.is_available())\n",
    "itera = iter(test_loader)\n",
    "\n",
    "\n",
    "def get_next_im():\n",
    "    test_data = next(itera)\n",
    "    return test_data[0].to(device), test_data[1].unsqueeze(0).to(device)\n",
    "\n",
    "\n",
    "def plot_occlusion_heatmap(im, heatmap):\n",
    "    plt.subplots(1, 2)\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.imshow(np.squeeze(im.cpu()))\n",
    "    plt.colorbar()\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.imshow(heatmap)\n",
    "    plt.colorbar()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get a random image and its corresponding label\n",
    "img, label = get_next_im()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Computing occlusion sensitivity: 100%|██████████| 64/64 [00:00<00:00, 143.99it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1800x1080 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get the occlusion sensitivity map\n",
    "occ_sens = monai.visualize.OcclusionSensitivity(\n",
    "    nn_module=model, mask_size=12, n_batch=10, stride=12)\n",
    "# Only get a single slice to save time.\n",
    "# For the other dimensions (channel, width, height), use\n",
    "# -1 to use 0 and img.shape[x]-1 for min and max, respectively\n",
    "depth_slice = img.shape[2] // 2\n",
    "occ_sens_b_box = [-1, -1, depth_slice, depth_slice, -1, -1, -1, -1]\n",
    "\n",
    "occ_result, _ = occ_sens(x=img, b_box=occ_sens_b_box)\n",
    "occ_result = occ_result[..., label.item()]\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(25, 15), facecolor='white')\n",
    "\n",
    "for i, im in enumerate([img[:, :, depth_slice, ...], occ_result]):\n",
    "    cmap = 'gray' if i == 0 else 'jet'\n",
    "    ax = axes[i]\n",
    "    im_show = ax.imshow(np.squeeze(im[0][0].detach().cpu()), cmap=cmap)\n",
    "    ax.axis('off')\n",
    "    fig.colorbar(im_show, ax=ax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cleanup data directory\n",
    "\n",
    "Remove directory if a temporary was used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "if directory is None:\n",
    "    shutil.rmtree(root_dir)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
